home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 15 / BBS in a box XV-2.iso / Files II / Prog / T / The Journal.sit / The Journal / journal Driver / journalDriver.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-03-16  |  16.9 KB  |  714 lines  |  [TEXT/KAHL]
  1.  
  2. #include <SetUpA4.h>
  3. #include "journalDriver.h"
  4.  
  5.  
  6. /* globals used by this driver */
  7.  
  8.     int        eventFlags ;            /* future expansion for event types to trap */
  9.     int        fileRefNum ;
  10.     int        stateFlags ;            /* flags used by driver */
  11.     Str255    appName ;                /* name of current application */
  12.  
  13.  
  14.  
  15. int main(cntrlParam *paramBlock, DCtlPtr devCtlEntry, int n)
  16. {
  17.     int    err ;
  18.  
  19.     RememberA4() ;
  20.  
  21.     switch(n) {
  22.         case CMD_OPEN:
  23.         case CMD_PRIME:
  24.         case CMD_STATUS:
  25.             return noErr ;
  26.             break ;
  27.  
  28.         case CMD_CONTROL:
  29.             SetUpA4() ;
  30.             err = DRVRControl(paramBlock, devCtlEntry) ;
  31.             RestoreA4() ;
  32.             break ;
  33.         
  34.         case CMD_CLOSE:
  35.             return -24 ;
  36.             break ;
  37.     }
  38. }
  39.  
  40. /*----------------------
  41.  
  42.     DRVRControl
  43.     
  44.     The control routine. There are two main sources of control calls
  45.     for this driver, the cdev or the journaling mechanism.
  46.     
  47.     Calls from the cdev are either configuration calls or enabling/disabling
  48.     calls.
  49.     
  50.     Calls from the journaling mechanism only occur when the journaling is
  51.     activated by a cdev control call. If recording is taking place, events
  52.     that are required are recorded into a journal file. The cdev will have
  53.     made calls to specify the required types of events for recording.
  54.  
  55. ------------------------*/
  56.  
  57. int DRVRControl(CntrlParam *ctlPB, DCtlPtr dCtl)
  58. {
  59.     int             refNum ;
  60.     OSErr            err ;
  61.     P_JrnlFileParam params ;
  62.     SignedByte        permission = fsRdWrPerm ;
  63.  
  64.     if (dCtl->dCtlStorage == NULL)
  65.         return noErr ;
  66.     
  67.     refNum = dCtl->dCtlRefNum ;
  68.  
  69.     switch (ctlPB->csCode) {
  70.         case JRNL_PLAY_CNTRL:
  71.             break ;
  72.             
  73.         case JRNL_RECORD_CNTRL:
  74.             DoJournalRecord(ctlPB) ;
  75.             break ;
  76.             
  77.         case JRNL_ON:
  78.             *((int*)JournalRef) = refNum ;
  79.             *((int*)JournalFlag) = JRNL_RECORD ;
  80.             
  81.             break ;
  82.         
  83.         case JRNL_OFF:
  84.             *((int*)JournalFlag) = JRNL_NEUTRAL ;
  85.             *((int*)JournalRef) = JRNL_NEUTRAL ;
  86.  
  87.             err = FSClose((fileRefNum)) ;
  88.  
  89.             break ;
  90.             
  91.         
  92.         case JRNL_OPEN_FILE:
  93.             params = (P_JrnlFileParam)(ctlPB->csParam) ;
  94.             eventFlags = params->eventFlags ;
  95.             err = HCreate(params->vRefNum, params->dirID, params->fName,
  96.                                 params->creator, 'TEXT') ;
  97.             err = HOpen(params->vRefNum, params->dirID, params->fName, 
  98.                         permission, &fileRefNum) ;
  99.             WriteCdevParams(params) ;
  100.             break ;
  101.     }
  102.     return noErr ;
  103. }
  104.  
  105.  
  106. /*----------------------
  107.  
  108.     DoJournalRecord
  109.     
  110. ------------------------*/
  111.  
  112. void DoJournalRecord(CntrlParam *paramBlock)
  113. {
  114.     int         callType ;
  115.     EventRecord    *eventPtr ;
  116.     long            count ;
  117.     OSErr            err ;
  118.     char            *eventString ;
  119.     unsigned long    dateTime ;
  120.     Str255        theTime ;
  121.     Str255        curAppName ;
  122.     int            apRefNum ;
  123.     Handle        appParams ;
  124.     
  125.     callType = (paramBlock->csParam)[2] ;    
  126.  
  127.     switch(callType) {
  128.         case JRNL_TICK_COUNT:
  129.             break ;
  130.             
  131.         case JRNL_GET_MOUSE:
  132.             break ;
  133.             
  134.         case JRNL_BUTTON:
  135.             break ;
  136.             
  137.         case JRNL_GET_KEYS:
  138.             break ;
  139.             
  140.         case JRNL_EVENT:
  141.             eventPtr = (*(EventRecord**)paramBlock->csParam) ;
  142.             
  143.             if (eventPtr->what != nullEvent) {
  144.             
  145.                 if ( (!(IsSet(stateFlags, STATE_KEY_BIT)))  && 
  146.                     IsSet(eventFlags, TIME_STAMP_BIT)) {
  147.                     /* print out time stamp */
  148.                     
  149.                     eventString = EV_DELIMIT ;
  150.                     PrintIt(err, fileRefNum, count, eventString) ;
  151.                     GetDateTime(&dateTime) ;
  152.                     IUTimeString(dateTime, TRUE, theTime) ;
  153.                     PrintIt(err, fileRefNum, count, theTime) ;
  154.                     eventString = EV_RETURN ;
  155.                     PrintIt(err, fileRefNum, count, eventString) ;
  156.                 }
  157.                 /* print out application name if new */
  158.                 
  159.                 GetAppParms(curAppName, &apRefNum, &appParams) ;
  160.                 if (IUCompString(curAppName, (appName)) != 0) {
  161.                     eventString = EV_APPLIC_NAME ;
  162.                     PrintIt(err, fileRefNum, count, eventString) ;
  163.                     GetAppParms((appName), &apRefNum, &appParams) ;
  164.                     PrintIt(err, fileRefNum, count, appName) ;
  165.                     eventString = EV_RETURN ;
  166.                     PrintIt(err, fileRefNum, count, eventString) ;
  167.                 }
  168.  
  169.                 switch (eventPtr->what) {
  170.                     case mouseDown:
  171.                     case mouseUp:
  172.                         eventString = NULL ;
  173.                         DoMouseDown(eventPtr) ;
  174.                         SetFlag(stateFlags, STATE_EVENT_MOUSE) ;
  175.                         ClearFlag(stateFlags, STATE_EVENT_KEY) ;
  176.                         ClearFlag(stateFlags, STATE_EVENT_OTHER) ;
  177.                         break ;
  178.                         
  179.                     case keyDown:        
  180.                     case autoKey:
  181.                         eventString = NULL ;
  182.                         DoKeyDown(eventPtr) ; 
  183.                         SetFlag(stateFlags, STATE_EVENT_KEY) ;
  184.                         ClearFlag(stateFlags, STATE_EVENT_MOUSE) ;
  185.                         ClearFlag(stateFlags, STATE_EVENT_OTHER) ;
  186.                         ClearMouseBits(stateFlags) ;            
  187.                         break ;
  188.  
  189.                     case updateEvt:    
  190.                         eventString = EV_UPDATE ;    
  191.                         break ;
  192.                     case diskEvt:        
  193.                         eventString = EV_DISK ;    
  194.                         break ;
  195.                     case networkEvt:    
  196.                         eventString = EV_UPDATE ;    
  197.                         break ;
  198.                     case driverEvt:    
  199.                         eventString = EV_DRIVER ;    
  200.                         break ;
  201.                     case app1Evt:        
  202.                         eventString = EV_APP1 ;    
  203.                         break ;
  204.                     case app2Evt:        
  205.                         eventString = EV_APP2 ;    
  206.                         break ;
  207.                     case app3Evt:        
  208.                         eventString = EV_APP3 ;    
  209.                         break ;
  210.                     case app4Evt:
  211.                         switch    (((unsigned long)eventPtr->message) >> 24) {
  212.                             case MouseMovedEvt:
  213.                                 eventString = EV_MOUSE_MOVED ;    
  214.                                 break ;
  215.                                 
  216.                             case SuspendResumeEvt:
  217.                                 if (eventPtr->message & activeFlag)
  218.                                     eventString = EV_SUSPENDING ;    
  219.                                 else
  220.                                     eventString = EV_RESUMING ;    
  221.                         }
  222.                         break ;
  223.  
  224.                     case activateEvt:
  225.                         if ((eventPtr->modifiers & activeFlag) == 0)
  226.                             eventString = EV_DEACTIVATE ;    
  227.                         else
  228.                             eventString = EV_ACTIVATE ;    
  229.                         break ;
  230.                 }
  231.                 
  232.                 if (eventString != NULL) {
  233.                     SetFlag(stateFlags, STATE_EVENT_OTHER) ;
  234.                     ClearFlag(stateFlags, STATE_EVENT_KEY) ;
  235.                     ClearFlag(stateFlags, STATE_EVENT_MOUSE) ;
  236.                     ClearMouseBits(stateFlags) ;            
  237.  
  238.                     if (IsSet(stateFlags, STATE_KEY_BIT)) {
  239.                         eventString = EV_ONLY_RETURN ;
  240.                         PrintIt(err, fileRefNum, count, eventString) ;
  241.                         ClearFlag(stateFlags, STATE_KEY_BIT) ;
  242.                     }
  243.                         
  244.                     PrintIt(err, fileRefNum, count, eventString) ;
  245.                     eventString = EV_RETURN ;
  246.                     PrintIt(err, fileRefNum, count, eventString) ;
  247.                 }
  248.             }
  249.             break ;
  250.             
  251.     }
  252. }
  253.  
  254.  
  255. /*----------------------
  256.  
  257.     DoMouseDown
  258.     
  259.     Handle a mouse down type event. What gets written depends
  260.     on where the mouse went down and if it is a double
  261.     click.
  262.     
  263. ------------------------*/
  264.  
  265. void DoMouseDown(EventRecord *eventPtr)
  266. {
  267.     int                mouseIn, result ;
  268.     WindowPtr        theWindow ;
  269.     long                count, menuHit ;
  270.     OSErr                err ;    
  271.     char                *eventString ;
  272.     Boolean            mDown ;             /* TRUE if this is a mouse down */
  273.     Point                hitPoint ;
  274.     ControlHandle    theControl ;
  275.     Str255            controlName ;
  276.  
  277.     mDown = (eventPtr->what == mouseDown) ;
  278.     
  279.     mouseIn = FindWindow(eventPtr->where, &theWindow) ;
  280.  
  281.     /* print out the window title */
  282.     if (theWindow != NULL) {
  283.         PrintWindowTitle(TRUE) ;
  284.     }
  285.  
  286.     if (IsSet(stateFlags, STATE_KEY_BIT)) {
  287.         eventString = EV_ONLY_RETURN ;
  288.         PrintIt(err, fileRefNum, count, eventString) ;
  289.         ClearFlag(stateFlags, STATE_KEY_BIT) ;
  290.     }
  291.  
  292.     eventString = (eventPtr->what == mouseDown) ? EV_MOUSE_DOWN : EV_MOUSE_UP ;
  293.     PrintIt(err, fileRefNum, count, eventString) ;
  294.  
  295.     switch (mouseIn) {
  296.     
  297.         case inDesk:
  298.             ClearMouseBits(stateFlags) ;            
  299.             eventString = EV_IN_DESK ;
  300.             break ;
  301.  
  302.         case inMenuBar:
  303.             if (mDown) {
  304.                 ClearMouseBits(stateFlags) ;
  305.                 SetFlag(stateFlags, STATE_MOUSE_MENU_BIT) ;
  306.             }
  307.             else 
  308.                 if ((IsSet(stateFlags, STATE_EVENT_MOUSE)) &&
  309.                      (IsSet(stateFlags, STATE_MOUSE_MENU_BIT))) {
  310.                     ClearMouseBits(stateFlags) ;
  311.                     menuHit = *((long*)MenuDisable) ;
  312.                     PrintMenuTitle(-1, menuHit) ;                     
  313.                 }
  314.             eventString = EV_IN_MENU_BAR ;
  315.             break ;
  316.  
  317.         case inSysWindow:
  318.             ClearMouseBits(stateFlags) ;            
  319.             eventString = EV_IN_SYS_WIND ;
  320.             break ;
  321.  
  322.         case inContent:
  323.             eventString = EV_IN_CONTENT ;
  324.             if (mDown) {
  325.                 ClearMouseBits(stateFlags) ;
  326.                 SetFlag(stateFlags, STATE_MOUSE_CONTENT_BIT) ;
  327.             }
  328.             else 
  329.                 if ( (IsSet(stateFlags, STATE_EVENT_MOUSE)) &&
  330.                       (IsSet(stateFlags, STATE_MOUSE_CONTENT_BIT)) ) {
  331.  
  332.                     ClearMouseBits(stateFlags) ;
  333.                     hitPoint.v  = eventPtr->where.v ;
  334.                     hitPoint.h = eventPtr->where.h ;
  335.                     GlobalToLocal(&hitPoint) ;
  336.                     result = FindControl(hitPoint, theWindow, &theControl) ;
  337.                     if (theControl != NULL) {
  338.                         GetCTitle(theControl, controlName) ;
  339.                         if (controlName[0] > 0) {
  340.                             PrintIt(err, fileRefNum, count, controlName) ;
  341.                             eventString = NULL ;
  342.                         }
  343.                     }
  344.                 }
  345.             
  346.             break ;
  347.  
  348.         case inDrag:
  349.             if (mDown) {
  350.                 ClearMouseBits(stateFlags) ;            
  351.                 SetFlag(stateFlags, STATE_MOUSE_DRAG_BIT) ;
  352.             }
  353.             else
  354.                 if ((IsSet(stateFlags, STATE_EVENT_MOUSE)) &&
  355.                      (IsSet(stateFlags, STATE_MOUSE_DRAG_BIT))) {
  356.                     ClearMouseBits(stateFlags) ;
  357.                     menuHit = *((long*)MenuDisable) ;
  358.                     PrintWindowTitle(TRUE) ;                                 
  359.                 }
  360.             eventString = EV_IN_DRAG ;
  361.             break ;
  362.  
  363.         case inGrow:
  364.             if (mDown) {
  365.                 ClearMouseBits(stateFlags) ;            
  366.                 SetFlag(stateFlags, STATE_MOUSE_GROW_BIT) ;
  367.             }
  368.             else
  369.                 if ((IsSet(stateFlags, STATE_EVENT_MOUSE)) &&
  370.                      (IsSet(stateFlags, STATE_MOUSE_GROW_BIT))) {
  371.                     ClearMouseBits(stateFlags) ;
  372.                     menuHit = *((long*)MenuDisable) ;
  373.                     PrintWindowTitle(TRUE) ;                                 
  374.                 }
  375.             eventString = EV_IN_GROW ;
  376.             break ;
  377.  
  378.         case inGoAway:
  379.             if (mDown) {
  380.                 ClearMouseBits(stateFlags) ;            
  381.                 SetFlag(stateFlags, STATE_MOUSE_GOAWAY_BIT) ;
  382.             }
  383.             else
  384.                 if ((IsSet(stateFlags, STATE_EVENT_MOUSE)) &&
  385.                      (IsSet(stateFlags, STATE_MOUSE_GOAWAY_BIT))) {
  386.                     ClearMouseBits(stateFlags) ;
  387.                     menuHit = *((long*)MenuDisable) ;
  388.                     PrintWindowTitle(TRUE) ;                                 
  389.                 }
  390.             eventString = EV_IN_GO_AWAY ;
  391.             break ;
  392.  
  393.         case inZoomIn:
  394.             if (mDown) {
  395.                 ClearMouseBits(stateFlags) ;            
  396.                 SetFlag(stateFlags, STATE_MOUSE_ZOOMIN_BIT) ;
  397.             }
  398.             else
  399.                 if ((IsSet(stateFlags, STATE_EVENT_MOUSE)) &&
  400.                      (IsSet(stateFlags, STATE_MOUSE_ZOOMIN_BIT))) {
  401.                     ClearMouseBits(stateFlags) ;
  402.                     menuHit = *((long*)MenuDisable) ;
  403.                     PrintWindowTitle(TRUE) ;                                 
  404.                 }
  405.             eventString = EV_IN_ZOOM_IN ;
  406.             break ;
  407.  
  408.         case inZoomOut:
  409.             if (mDown) {
  410.                 ClearMouseBits(stateFlags) ;            
  411.                 SetFlag(stateFlags, STATE_MOUSE_ZOOMOUT_BIT) ;
  412.             }
  413.             else
  414.                 if ((IsSet(stateFlags, STATE_EVENT_MOUSE)) &&
  415.                      (IsSet(stateFlags, STATE_MOUSE_ZOOMOUT_BIT))) {
  416.                     ClearMouseBits(stateFlags) ;
  417.                     menuHit = *((long*)MenuDisable) ;
  418.                     PrintWindowTitle(TRUE) ;                                 
  419.                 }
  420.             eventString = EV_IN_ZOOM_OUT ;
  421.             break ;
  422.     }
  423.     if (eventString != NULL) {
  424.         PrintIt(err, fileRefNum, count, eventString) ;
  425.     }
  426. }
  427.  
  428.  
  429.  
  430.  
  431. /*----------------------
  432.  
  433.     DoKeyDown
  434.     
  435.     Handle a keyDown event. The basic flow of this function is :
  436.     
  437.         get the ASCII character pressed from the event record
  438.         if the Command Key was pressed
  439.             if the use canceled (cmd-.)
  440.                 write out the cancel
  441.             else
  442.                 (write out menu event )
  443.                 
  444.                 if selected a menu item by command key
  445.                     write out the menu item
  446.                 else
  447.                     write out the key press
  448.         else
  449.             update printing characters flag
  450.             if the character is printable
  451.                 print out the character
  452.             else
  453.                 print out a character representation
  454.                 if the character is a linefeed or return
  455.                     write out a return
  456.     
  457. ------------------------*/
  458.  
  459. void DoKeyDown(EventRecord *eventPtr)
  460. {
  461.     char            *eventString ;
  462.     long            count ;
  463.     OSErr            err ;
  464.     char            keyPress ;
  465.     int            keyCode ;
  466.     long            menuHit ;
  467.  
  468.     keyPress = eventPtr->message & charCodeMask ;
  469.  
  470.     if (eventPtr->modifiers & cmdKey) {
  471.         /* command key press of some type */
  472.  
  473.         if (IsSet(stateFlags, STATE_KEY_BIT)) {
  474.             eventString = EV_ONLY_RETURN ;
  475.             PrintIt(err, fileRefNum, count, eventString) ;
  476.             ClearFlag(stateFlags, STATE_KEY_BIT) ;
  477.         }
  478.  
  479.         if (keyPress == '.') {
  480.             eventString = EV_CANCEL ;
  481.             PrintIt(err, fileRefNum, count, eventString) ;
  482.         }
  483.         else {
  484.             menuHit = MenuKey(keyPress) ;
  485.             PrintMenuTitle(keyPress, menuHit) ;
  486.         }
  487.     }
  488.     else {
  489.         /* entering normal text or control/shift/option key modifications */
  490.         
  491.  
  492.         PrintWindowTitle((!(IsSet(stateFlags, STATE_KEY_BIT)))) ;
  493.         SetFlag(stateFlags, STATE_KEY_BIT) ;
  494.         
  495.         if (isascii(keyPress)) {
  496.             if ((isprint(keyPress)) || (keyPress == '\015') || (keyPress == '\012')) {
  497.                 if ((keyPress == '\015') || (keyPress == '\012')) {
  498.                     eventString = EV_CR ;
  499.                     PrintIt(err, fileRefNum, count, eventString) ;
  500.                 }
  501.                 count = 1 ;
  502.                 err = FSWrite((fileRefNum), &count, (Ptr) &keyPress) ;
  503.             }
  504.             else {
  505.                 keyCode = (eventPtr->message & keyCodeMask)>>8 ;
  506.                 eventString = GetNonPrintingKey(keyCode) ;
  507.                 PrintIt(err, fileRefNum, count, eventString) ;
  508.             }
  509.         }
  510.         else { 
  511.             /* an extended printable mac character */
  512.             count = 1 ;
  513.             err = FSWrite((fileRefNum), &count, (Ptr) &keyPress) ;
  514.         }
  515.     }
  516. }
  517.  
  518.  
  519. /*----------------------
  520.  
  521.     PrintMenuTitle
  522.     
  523.     Print out the item name and menu title for a menu selection.
  524.     
  525. ------------------------*/
  526.  
  527. void PrintMenuTitle(char keyPress, long menuHit)
  528. {
  529.     long            count ;
  530.     Str255        menuStr ;
  531.     int            menuID, menuItem ;
  532.     MenuHandle    menuH ;
  533.     OSErr            err ;
  534.     char            *eventString ;
  535.     long            enableTest ;
  536.  
  537.     eventString = EV_MENU_TITLE ;    
  538.     PrintIt(err, fileRefNum, count, eventString) ;
  539.  
  540.     menuID = HiWord(menuHit) ;
  541.     menuItem = LoWord(menuHit) ;
  542.     menuH = GetMHandle(menuID) ;
  543.     if (menuH != NULL) {
  544.         eventString = (char*)((MenuPtr)(*menuH))->menuData ;
  545.         if ((eventString[0] == 1) && (eventString[1] == APPLE_MENU_CHAR))
  546.             eventString = EV_APPLE_MENU ;
  547.         PrintIt(err, fileRefNum, count, eventString) ;
  548.  
  549.         eventString = EV_MENU_ITEM ;
  550.         PrintIt(err, fileRefNum, count, eventString) ;
  551.  
  552.         GetItem(menuH, menuItem, menuStr) ;
  553.         PrintIt(err, fileRefNum, count, menuStr) ;
  554.  
  555.         if (menuItem < 32) {
  556.             enableTest = 1<<menuItem ;
  557.             if ( !(((MenuPtr)(*menuH))->enableFlags & enableTest)) {
  558.                 eventString = EV_MENU_DISABLE ;
  559.                 PrintIt(err, fileRefNum, count, eventString) ;
  560.             }
  561.         }
  562.     }
  563.     else
  564.         if (keyPress != -1) {
  565.             eventString = EV_CMD_KEY ;
  566.             PrintIt(err, fileRefNum, count, eventString) ;
  567.             count = 1 ;
  568.             err = FSWrite((fileRefNum), &count, (Ptr) &keyPress) ; 
  569.         }
  570.     eventString = EV_RETURN ;
  571.     PrintIt(err, fileRefNum, count, eventString) ;
  572. }
  573.  
  574.  
  575.  
  576. /*----------------------
  577.  
  578.     PrintWindowTitle
  579.     
  580.     Print out the title and general kind of a window.
  581.     
  582. ------------------------*/
  583.  
  584. void PrintWindowTitle(Boolean mustPrint)
  585. {
  586.     WindowPtr    theWindow ;
  587.     long            count ;
  588.     Str255        windowName ;
  589.     char             *eventString ;
  590.     OSErr            err ;
  591.     Boolean        transition ;    /* transition between window and/or dialog */
  592.  
  593.     
  594.     theWindow = FrontWindow() ;
  595.     transition = mustPrint ;
  596.     
  597.     if (theWindow != NULL) {
  598.         if ( ((WindowPeek)theWindow)->windowKind == 2 ) {
  599.             eventString = EV_KEY_DIALOG ;
  600.             if (IsSet(stateFlags, STATE_WINDOW_BIT)) {
  601.                 ClearFlag(stateFlags, STATE_WINDOW_BIT) ;
  602.                 transition = TRUE ;
  603.             }
  604.             SetFlag(stateFlags, STATE_DIALOG_BIT) ;
  605.         }
  606.         else {
  607.             if (IsSet(stateFlags, STATE_DIALOG_BIT)) {
  608.                 ClearFlag(stateFlags, STATE_DIALOG_BIT) ;
  609.                 transition = TRUE ;
  610.             }
  611.             SetFlag(stateFlags, STATE_WINDOW_BIT) ;
  612.             eventString = EV_KEY_WINDOW ;
  613.         }
  614.  
  615.         if (transition) {
  616.             PrintIt(err, fileRefNum, count, eventString) ;
  617.             GetWTitle(theWindow, windowName) ;
  618.             if (windowName[0] > 0) {
  619.                 PrintIt(err, fileRefNum, count, windowName) ;
  620.             }
  621.             else {
  622.                 eventString = EV_NO_WIND_NAME ;
  623.                 PrintIt(err, fileRefNum, count, eventString) ;
  624.             }
  625.             eventString = EV_RETURN ;
  626.             PrintIt(err, fileRefNum, count, eventString) ;
  627.         }
  628.     }
  629.     else {
  630.         eventString = EV_KEY_NO_NAME ;
  631.         PrintIt(err, fileRefNum, count, eventString) ;
  632.     }
  633. }
  634.         
  635. /*----------------------
  636.  
  637.     WriteCdevParams
  638.     
  639.     Write out information to the file about what state parameters
  640.     are set in cdev when the file is opened.
  641.     
  642. ------------------------*/
  643.  
  644. void WriteCdevParams(P_JrnlFileParam params)
  645. {
  646.     long    count ;
  647.     OSErr    err ;
  648.  
  649.     count = 21 ;
  650.     err = FSWrite((fileRefNum), &count, "--------------------\015") ;                                
  651.     count = 27 ;
  652.     err = FSWrite((fileRefNum), &count, "State Parameters from cdev\015") ;                                
  653.     if (params->eventFlags & TIME_STAMP_BIT) {
  654.                     count = 11 ;
  655.                     err = FSWrite((fileRefNum), &count, "Time Stamp\015") ;
  656.     }
  657.     
  658.     count = 22 ;
  659.     err = FSWrite((fileRefNum), &count, "--------------------\015\015") ;                                
  660.  
  661. }
  662.  
  663.  
  664.         
  665. /*----------------------
  666.  
  667.     GetNonPrintingKey
  668.     
  669.     Return the correct string for a non-printing key.
  670.     
  671. ------------------------*/
  672.  
  673. char *GetNonPrintingKey(int keyCode)
  674. {
  675.     char        *returnVal ;
  676.     
  677.     switch(keyCode) {
  678.         case 0x30: returnVal = EV_TAB ; break ;
  679.         case 0x33: returnVal = EV_BACKSPACE ; break ;
  680.         case 0x35: returnVal = EV_ESCAPE ; break ;
  681.         case 0x4C: returnVal = EV_ENTER ; break ;
  682.         case 0x47: returnVal = EV_CLEAR ; break ;
  683.         case 0x60: returnVal = EV_F5 ; break ;
  684.         case 0x61: returnVal = EV_F6 ; break ;
  685.         case 0x62: returnVal = EV_F7 ; break ;
  686.         case 0x63: returnVal = EV_F3 ; break ;
  687.         case 0x64: returnVal = EV_F8 ; break ;
  688.         case 0x65: returnVal = EV_F9 ; break ;
  689.         case 0x67: returnVal = EV_F11 ; break ;
  690.         case 0x69: returnVal = EV_F13 ; break ;
  691.         case 0x6B: returnVal = EV_F14 ; break ;
  692.         case 0x6D: returnVal = EV_F10 ; break ;
  693.         case 0x6F: returnVal = EV_F12 ; break ;
  694.         case 0x71: returnVal = EV_F15 ; break ;
  695.         case 0x72: returnVal = EV_HELP ; break ;
  696.         case 0x73: returnVal = EV_HOME ; break ;
  697.         case 0x74: returnVal = EV_PAGE_UP ; break ;
  698.         case 0x75: returnVal = EV_DELETE ; break ;
  699.         case 0x76: returnVal = EV_F4 ; break ;
  700.         case 0x77: returnVal = EV_END ; break ;
  701.         case 0x78: returnVal = EV_F2 ; break ;
  702.         case 0x79: returnVal = EV_PAGE_DOWN ; break ;
  703.         case 0x7A: returnVal = EV_F1 ; break ;
  704.         case 0x7B: returnVal = EV_LEFT_ARROW ; break ;
  705.         case 0x7C: returnVal = EV_RIGHT_ARROW ; break ;
  706.         case 0x7D: returnVal = EV_DOWN_ARROW ; break ;
  707.         case 0x7E: returnVal = EV_UP_ARROW ; break ;
  708.         case 0x7F: returnVal = EV_RESET ; break ;
  709.         default: returnVal = EV_UNKNOWN_CTRL ;
  710.     }
  711.     return returnVal ;
  712. }
  713.  
  714.